home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 426-450 / disk_445 / optmouse / optmouse.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  8KB  |  345 lines
  1. /*
  2.  * OptMouse.c
  3.  *
  4.  * Serial Port Optical Mouse Driver
  5.  *
  6.  * (c) Copyright 1989 J. Edward Hanway
  7.  * This code may be freely redistributed for non-commercial purposes. There
  8.  * is NO WARRANTY on this program. The author assumes no responsibility for
  9.  * any damages resulting from use of this program. You know the drill.
  10.  *
  11.  * Language: Lattice C 5.02
  12.  *
  13.  * Revision History:
  14.  *
  15.  * Version 1.0    27 May 1989
  16.  *    Supports Mouse Systems M2/M3 serial optical mouse
  17.  * Version 1.1  3 June 1989
  18.  *    Added support for other device/unit combinations besides serial.device
  19.  *    (e.g. siosbx.device) *** NOTE: This feature has not been tested. ***
  20.  */
  21.  
  22. #define VERSION "1.1"
  23.  
  24. #include <exec/types.h>
  25. #include <devices/serial.h>
  26. #include <devices/input.h>
  27. #include <devices/inputevent.h>
  28. #include <devices/keyboard.h>
  29. #include <libraries/dos.h>
  30. #include <proto/exec.h>
  31. #include <proto/dos.h>
  32. #include <string.h>
  33. #include <stdlib.h>
  34.  
  35. #define SAY(x) \
  36. {if(_Backstdout) {Write(_Backstdout, (x), strlen(x)); Close(_Backstdout);}}
  37.  
  38. void MemCleanup() {}
  39.  
  40. /* This stuff is for linking with cback.o (for "load and stay resident" code) */
  41.  
  42. LONG    _stack = 4000;        /* stack size */
  43. char    *_procname = "OptMouse";/* process name */
  44. LONG    _priority = 20;        /* priority */
  45. LONG    _BackGroundIO = 1;    /* requires I/O */
  46. extern BPTR _Backstdout;
  47.  
  48. static char        *ser_portname = "OptMouse";
  49.     
  50. /* default device/unit */
  51. static char        *device = SERIALNAME;
  52. static int        unit = 0;
  53.  
  54.  
  55. static struct dev {
  56.     struct MsgPort        *port;
  57.     struct IORequest    *iob;
  58.     BOOL            open;
  59. }    ser = {NULL, NULL, FALSE},
  60.     in = {NULL, NULL, FALSE},
  61.     time = {NULL, NULL, FALSE},
  62.     key = {NULL, NULL, FALSE};
  63.     
  64. /* shorthand */
  65. #define SER_IOB        ((struct IOExtSer *)(ser.iob))
  66. #define IN_IOB        ((struct IOStdReq *)(in.iob))
  67. #define TIME_IOB    ((struct timerequest *)(time.iob))
  68. #define KEY_IOB        ((struct IOStdReq *)(key.iob))
  69.  
  70. static signed char    b;            /* byte read from mouse */
  71.  
  72. static struct button {
  73.     BOOL left, middle, right;
  74. }    button, last_button = { FALSE, FALSE, FALSE };
  75.  
  76. static struct InputEvent event = {
  77.     NULL,                /* NextEvent */
  78.     IECLASS_RAWMOUSE,        /* Class */
  79.     NULL,                /* SubClass */
  80.     NULL,                /* Code, filled in later */
  81.     NULL,                /* Qualifier, filled in later */
  82.     { NULL, NULL },            /* Position, filled in later */
  83.     { 0L, 0L }            /* TimeStamp */    
  84. };
  85.  
  86. /* Matrix for reading key states. All we care about are the 
  87.  * shift/ctrl/alt/amiga keys, which are conveniently qrouped in
  88.  * keymatrix[12] in the same order as required for the qualifier
  89.  *
  90.  * The following number, which is the ONLY read length that works for
  91.  * KBD_READMATRIX, was documented NOWHERE! I had to find it by trial and error.
  92.  */
  93. #define GODDAMN_KEY_MATRIX_READ_LENGTH    13
  94.  
  95. static UBYTE keymatrix[16];
  96.  
  97. void close_dev(struct dev *dev)
  98. {
  99.     if(dev->open) {
  100.         AbortIO(dev->iob);
  101.         CloseDevice(dev->iob);
  102.         dev->open = FALSE;
  103.     }
  104.     if(dev->iob) {
  105.         DeleteExtIO(dev->iob);
  106.         dev->iob = NULL;
  107.     }
  108.     if(dev->port) {
  109.         DeletePort(dev->port);
  110.         dev->port = NULL;
  111.     }
  112. }
  113.  
  114. void die(void)
  115. {
  116.     close_dev(&time);
  117.     close_dev(&in);
  118.     close_dev(&ser);
  119.     close_dev(&key);
  120.     _exit(0);
  121. }
  122.  
  123. void open_dev(struct dev *dev, char *portname, char *devname, int unit, int size)
  124. { 
  125.     if(!(dev->port = CreatePort(portname, 0)) ||
  126.        !(dev->iob = CreateExtIO(dev->port, size)) ||
  127.        !(dev->open = !OpenDevice(devname, unit, dev->iob, 0L))) {
  128.         SAY("Device error\n");
  129.         die();
  130.     }
  131. }
  132.  
  133. /* my_DoIO does everything that DoIO does (I hope) except it allows for a break
  134.  * signal.
  135.  */
  136. void my_DoIO(struct IORequest *iob)
  137. {
  138.     register LONGBITS signals, sigbit;
  139.  
  140. /* Lattice 5.02 doesn't seem to provide a register-parameter entry to BeginIO,
  141.  * so here's a hack that avoids an annoying 3 line assembly language program.
  142.  * Just don't try to call BeginIO on anything but iob->io_Device.
  143.  */
  144. #pragma libcall iob->io_Device BeginIO 1e 901
  145.  
  146.     iob->io_Flags |= IOF_QUICK;
  147.     BeginIO(iob);
  148.     if(!(iob->io_Flags & IOF_QUICK)) {
  149.         signals = Wait((sigbit = (1L << 
  150.                 iob->io_Message.mn_ReplyPort->mp_SigBit)) |
  151.                    SIGBREAKF_CTRL_C);
  152.         if(signals & sigbit)
  153.             GetMsg(iob->io_Message.mn_ReplyPort);
  154.         if(signals & SIGBREAKF_CTRL_C)
  155.             die();
  156.     }
  157. }
  158.  
  159. #undef isspace
  160.  
  161. int isspace(register char c)
  162. {
  163.     return ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r'));
  164. }
  165.  
  166. char *skiparg(register char *s)
  167. {
  168.     while(*s && !isspace(*s))
  169.         s++;
  170.     return s;
  171. }
  172.  
  173. char *skipwhite(register char *s)
  174. {
  175.     while(*s && isspace(*s))
  176.         s++;
  177.     return s;
  178. }
  179.  
  180. void _tinymain(char *s)
  181. {
  182.     UWORD        state = 0;
  183.     WORD        dx, dy;
  184.     BOOL        mid_is_shift = 0;
  185.     BOOL        kill = 0;
  186.  
  187.     /* I'm playing it fast and loose with parsing here */
  188.     s = skiparg(s);
  189.     s = skipwhite(s);
  190.     while(*s == '-') {
  191.         switch(*(s+1)) {
  192.             case 'k':
  193.             case 'K':
  194.             kill++;
  195.             break;
  196.             case 'm':
  197.             case 'M':
  198.             mid_is_shift++;
  199.             break;
  200.         }
  201.         s = skiparg(s);
  202.         s = skipwhite(s);
  203.     }
  204.  
  205.     /* device name */
  206.     if(*s) {
  207.         device = s;
  208.         s = skiparg(s);
  209.         if(*s) *s++ = '\0';
  210.         s = skipwhite(s);
  211.     }
  212.  
  213.     /* unit */
  214.     if(*s) {
  215.         (void) stcd_i(s, &unit);
  216.     }
  217.  
  218.     if(FindPort(ser_portname)) {
  219.         if(kill) {
  220.             Signal(FindTask(_procname),SIGBREAKF_CTRL_C);
  221.             SAY("Killed\n");
  222.         } else
  223.             SAY("Already installed\n");
  224.         die();
  225.     }
  226.  
  227.     open_dev(&ser, ser_portname, device, unit, sizeof(struct IOExtSer));
  228.     open_dev(&in, NULL, "input.device", 0L, sizeof(struct IOStdReq));
  229.     open_dev(&time, NULL, TIMERNAME, UNIT_MICROHZ, sizeof(struct timerequest));
  230.     open_dev(&key, NULL, "keyboard.device", 0L, sizeof(struct IOStdReq));
  231.  
  232.     SAY("OptMouse " VERSION " \xA9 Copyright 1989 J. Edward Hanway\n");
  233.  
  234.     /* Set serial port parameters:
  235.      * 1200 baud, 8 bits, no parity, 1 stop bit, no flow control
  236.      */
  237.     SER_IOB->IOSer.io_Command = SDCMD_SETPARAMS;
  238.     SER_IOB->io_Baud = 1200;
  239.     SER_IOB->io_ReadLen = 8;
  240.     SER_IOB->io_StopBits = 1;
  241.     SER_IOB->io_SerFlags = SERF_XDISABLED | SERF_RAD_BOOGIE;
  242.     my_DoIO(ser.iob);
  243.  
  244.     /* Since each IORequest will be used for only one type of command,
  245.      * lots of invariant fields can be filled in here
  246.      */
  247.     KEY_IOB->io_Command = KBD_READMATRIX;
  248.     KEY_IOB->io_Data = (APTR) keymatrix;
  249.     KEY_IOB->io_Length = GODDAMN_KEY_MATRIX_READ_LENGTH;
  250.  
  251.     TIME_IOB->tr_node.io_Command = TR_GETSYSTIME;
  252.  
  253.     IN_IOB->io_Command = IND_WRITEEVENT;
  254.     IN_IOB->io_Flags = 0;
  255.     IN_IOB->io_Length = sizeof(struct InputEvent);
  256.     IN_IOB->io_Data = (APTR) &event;
  257.  
  258.     SER_IOB->IOSer.io_Command = CMD_READ;
  259.     SER_IOB->IOSer.io_Length = 1;
  260.     SER_IOB->IOSer.io_Data = (APTR) &b;
  261.  
  262.     while(TRUE) {
  263.         my_DoIO(ser.iob);
  264.         switch(state) {
  265.             case 0:
  266.             if((b & 0xf8) == 0x80) {
  267.                 button.right  = !(b & (1 << 0));
  268.                 button.middle = !(b & (1 << 1));
  269.                 button.left   = !(b & (1 << 2));
  270.                 state++;
  271.             }
  272.             break;
  273.             case 1:
  274.             dx = b;
  275.             state++;
  276.             break;
  277.             case 2:
  278.             dy = b;
  279.             state++;
  280.             break;
  281.             case 3:
  282.             dx += b;
  283.             state++;
  284.             break;
  285.             case 4:
  286.             dy += b;
  287.  
  288.             /* Now compose the events to be sent to input.device.
  289.              * Currently, 0-4 events (movement, up to 3 button
  290.              * state changes) are sent.
  291.  
  292.             /* Valid time stamp is required for double-clicking
  293.              * to work properly.
  294.              */
  295.             my_DoIO(time.iob);
  296.             event.ie_TimeStamp = TIME_IOB->tr_time;
  297.  
  298.             /* Shift key status is needed for shift-click support */
  299.             my_DoIO(key.iob);
  300.  
  301.             event.ie_X = dx;
  302.             event.ie_Y = -dy;
  303.             event.ie_Code = IECODE_NOBUTTON;
  304.             event.ie_Qualifier = IEQUALIFIER_RELATIVEMOUSE |
  305.             (button.right ? IEQUALIFIER_RBUTTON : 0) |
  306.             ((button.middle && !mid_is_shift) ? IEQUALIFIER_MIDBUTTON : 0) |
  307.             (button.left ? IEQUALIFIER_LEFTBUTTON : 0) | 
  308.             keymatrix[12] |
  309.             ((button.middle && mid_is_shift) ? 
  310.              (IEQUALIFIER_LEFTBUTTON | IEQUALIFIER_LSHIFT) :
  311.              0);
  312.  
  313.             if(dx || dy)
  314.                 my_DoIO(in.iob);
  315.  
  316.             event.ie_X = event.ie_Y = 0;
  317.  
  318.             if(button.left ^ last_button.left) {
  319.                 event.ie_Code = button.left ? IECODE_LBUTTON :
  320.                         IECODE_LBUTTON | IECODE_UP_PREFIX;
  321.                 my_DoIO(in.iob);
  322.             }
  323.  
  324.             if(button.middle ^ last_button.middle) {
  325.                 event.ie_Code = mid_is_shift ? 
  326.                         (button.middle ? IECODE_LBUTTON :
  327.                          IECODE_LBUTTON | IECODE_UP_PREFIX) :
  328.                         (button.middle ? IECODE_MBUTTON : 
  329.                          IECODE_MBUTTON | IECODE_UP_PREFIX);
  330.                 my_DoIO(in.iob);
  331.             }
  332.  
  333.             if(button.right ^ last_button.right) {
  334.                 event.ie_Code = button.right ? IECODE_RBUTTON : 
  335.                         IECODE_RBUTTON | IECODE_UP_PREFIX;
  336.                 my_DoIO(in.iob);
  337.             }
  338.  
  339.             last_button = button;
  340.             state = 0;
  341.             break;
  342.         }
  343.     }
  344. }
  345.